package a

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"server/a0"
	"server/model/system"
	"slices"
	"time"

	"gorm.io/gorm"
)

func A取候选值单项组(字段 *S字段) (单项组 []map[string]any) {
	单项组 = make([]map[string]any, 0)
	// sps := A拆分id(字段.A候选值源字段)
	// 元件名 := sps[0]
	// 元件名 := sps[1]
	// 字段名 := sps[2]
	// 表名 := A成表名(元件名, 元件名)
	// 传递 元件名.元件名.字段名
	源元件, _ := A取字段(字段.A候选值源字段)
	元件名 := 源元件.A名称
	表名 := 源元件.A表名
	// 如果是设置的，不能直接取字段，没有直接定义结构体👇
	if 元件名 == "设置" {
		_, 字段名 := A拆分字段id(字段.A候选值源字段)
		var 字段值 string
		a0.A_DB.Table(表名).Where("名称 = ?", 字段名).Select("内容").Scan(&字段值)
		var values []string
		json.Unmarshal([]byte(字段值), &values)
		for _, value := range values {
			item := map[string]any{
				"label": value,
				"value": value,
			}
			单项组 = append(单项组, item)
		}
	} else {
		// 字段名 := "id"
		// if 源字段 != nil {
		// 	字段名 = 源字段.A名称
		// }
		// lable := 字段名
		// value := 字段名
		// a0.A_DB.Table(表名).Where("deleted_at IS NULL").Select(fmt.Sprintf("%s as label, %s as value", lable, value)).Scan(&单项组)
		a0.A_DB.Table(表名).Where("deleted_at IS NULL").Select("*").Scan(&单项组)

		// a0.A_DB.Table("lysd_商品").Where("deleted_at IS NULL").Select("类别 as label,id as value").Scan(&父级id)
	}
	return
}

func A增或改_单个(tx *gorm.DB, model any, 元件 *S元件, userID uint) (err error) {
	id := A取id(model)
	A证id记录(&id, model)
	// 如果前端传递的仅仅是变动的数据，需要预处理👇
	// if id != 0 {
	// 	model现存全, _ := 元件.Aservice.A查单个_公开(id)
	// 	源reqdata := 元件.A源reqdata
	// 	bytes, _ := json.Marshal(源reqdata)
	// 	_ = json.Unmarshal(bytes, &model现存全)
	// 	fmt.Printf("用前端传递的修改项重新解析后 model现存全 👉 %+v\n", model现存全)
	// 	model = model现存全
	// }

	if err = A证流程权限(model, 元件); err != nil {
		return
	}

	// 这里可能也要递归，再说……
	if 元件.A自动挡hook.A增或改之前s7 != nil {
		if A反射调用(元件.A自动挡hook.A增或改之前s7, model, userID) != nil {
			return err
		}
	}

	// 新增的时候要逐层予 子级 默认值,不需要递归👇
	if id == 0 {
		A增时予子级默认值(model, 元件)
	}

	// 设置为完全更新所有关联表👇
	tx = tx.Session(&gorm.Session{FullSaveAssociations: true})

	// 先处理子表👇
	err = A增或改_单个_预处理_递归(tx, model, 元件, userID)
	if err != nil {
		return
	}

	// 正式执行 增或改 ，利用gorm处理主表及关联表s👇
	tx = tx.Debug()
	// 新增
	if id == 0 {
		// 记录创建用户(&userID, model)
		if err = tx.Create(model).Error; err != nil {
			return err
		}
	} else {
		// 记录更新用户(&userID, model)
		// if err = tx.Model(&model).Where("id =?", id).Updates(model).Error; err != nil {
		tx = tx.Model(model)
		A指定更新字段(tx)
		if err = tx.Updates(model).Error; err != nil {
			return err
		}
	}

	// 先要保存,自动生成id后，再根据id生成编号
	A增或改_单个_后处理_递归(model, 元件, userID, false)
	// 改编号_有id后(model, "", false)
	if err = tx.Updates(model).Error; err != nil {
		return err
	}

	return err
}

func A取user(userID uint) (user system.SysUser) {
	err := a0.A_DB.Preload("Authorities").Preload("Authority").First(&user, "id = ?", userID).Error
	if err != nil {
		fmt.Printf("user 👉 %+v\n", user)
	}
	return
}

func A证数据权限(userID uint) (直接放行 bool, 允许用户ids []uint, err error) {
	user := A取user(userID)
	switch user.Authority.A数据范围 {
	case A数据范围_全部:
		直接放行 = true
		return
	case A数据范围_仅本人:
		允许用户ids = append(允许用户ids, userID)
		return
	case A数据范围_本部门不含下级, A数据范围_本部门及下级部门:
		部门id := A取部门id(userID)
		部门ids := []uint{部门id}
		if user.Authority.A数据范围 == A数据范围_本部门及下级部门 {
			子级部门ids := A取子部门ids(部门id)
			部门ids = append(部门ids, 子级部门ids...)
		}
		允许用户ids = append(允许用户ids, A取用户ids靠部门ids(部门ids)...)
	}
	fmt.Printf("允许用户ids 👉 %+v\n", 允许用户ids)
	if len(允许用户ids) == 0 {
		err = errors.New("无数据权限")
		return
	}
	return
}

// 在 人员表 中找 部门id 匹配的数据，从上面取用户id👇
func A取用户ids靠部门ids(部门ids []uint) (res []uint) {
	人员单项组 := make([]map[string]any, 0)
	err := a0.A_DB.Model(A人员model).Where("部门_部门id in ?", 部门ids).Scan(&人员单项组).Error
	if err != nil {
		fmt.Printf("err 👉 %+v\n", err)
		// return
	}
	for _, 人员单项 := range 人员单项组 {
		id := 人员单项["系统用户_用户id"]
		if id != nil {
			res = append(res, A转uint2(id))
		}
	}
	return
}

func A取子部门ids(部门id uint) (res []uint) {
	部门models := A元件集["基础.部门"].Aservice.查多个(S列表req{})
	目标部门models := A取子级(部门models, 部门id)
	fmt.Printf("目标部门models 👉 %+v\n", 目标部门models)
	res = A取ids(目标部门models)
	return
}

func A取部门id(userID uint) (res uint) {
	人员单项 := make(map[string]any, 0)
	err := a0.A_DB.Model(A人员model).Where("系统用户_用户id = ?", userID).Scan(&人员单项).Error
	if err != nil {
		fmt.Printf("err 👉 %+v\n", err)
	}
	// 部门id := A取字段值(A人员model, "A部门_S部门modelID").(uint)
	res = A转uint2(人员单项["部门_部门id"])
	return
}

func A证id记录(id *uint, model any) {
	var count int64
	a0.A_DB.Model(model).Where("id = ?", id).Count(&count)
	if count > 0 {
		fmt.Printf("存在 id 为 %d 的记录\n", id)
	} else {
		fmt.Printf("不存在 id 为 %d 的记录\n", id)
		*id = 0
		A予id值(model, *id)
	}
}

// 元件.Amodel中已经有了嵌套值，在这里不需要迭代
func A增时予子级默认值(model any, 元件 *S元件) (err error) {
	for _, 字段 := range 元件.A字段组 {
		switch 字段.A类型 {
		case "关联字段":
			关联类型, 关联元件 := A解关联属性(字段)
			if 关联类型 == A关联类型_属于 {
				break
			}
			if 关联类型 == A关联类型_一对多 {
				关联字段名 := 字段.A名称go
				子models := A取字段反射值(model, 关联字段名)
				aa := 子models.Len()
				fmt.Printf("aa 👉 %+v\n", aa)
				if 子models.Len() > 0 {
					break
				}
				关联元件model_含默认值 := 关联元件.Amodel
				// 创建一个新的切片并将 关联元件model_含默认值 放入其中
				newSlice := reflect.MakeSlice(子models.Type(), 1, 1)
				newSlice.Index(0).Set(reflect.ValueOf(关联元件model_含默认值))

				// 将新切片赋值给子models
				子models.Set(newSlice)
			}
		}
	}
	return nil
}

func A删_单个_可迭代(tx *gorm.DB, model any, 元件 *S元件) (err error) {
	if err = A证流程权限(model, 元件); err != nil {
		return
	}
	记录删除用户(model)
	tx.Delete(model)
	for _, 字段 := range 元件.A字段组 {
		关联元件 := A取一对一或多的关联元件(字段)
		if 关联元件 == nil {
			continue
		}
		关联字段名 := 字段.A名称go
		子models := A取字段反射值(model, 关联字段名)
		for i := range 子models.Len() {
			子model指针 := A取子model指针(子models.Index(i))
			A删_单个_可迭代(tx, 子model指针, 关联元件)
		}
	}

	// for _, 字段 := range 元件.A字段组 {
	// 	switch 字段.A类型 {
	// 	case "关联字段":
	// 		关联类型, 关联元件 := A解关联属性(字段)
	// 		if 关联类型 == A关联类型_属于 {
	// 			break
	// 		}
	// 		关联字段名 := 字段.A名称go
	// 		子models := A取字段反射值(model, 关联字段名)
	// 		for i := range 子models.Len() {
	// 			子model := A取反射el(子models.Index(i))
	// 			子model指针 := A取反射值指针(子model)
	// 			// 子表单项id := A取id(子model)
	// 			记录删除用户(&userID, 子model指针)
	// 			A删_单个_可迭代(tx, 子model指针, 关联元件, userID)
	// 			tx.Delete(子model指针)
	// 		}
	// 	}
	// }
	return nil
}

func A增或改_单个_预处理_递归(tx *gorm.DB, model any, 元件 *S元件, userID uint) (err error) {
	id := A取id(model)
	A证id记录(&id, model)
	if id == 0 {
		记录创建用户(&userID, model)
		A予状态_新增(model, 元件, userID)
	} else {
		记录更新用户(&userID, model)
	}

	// 处理子级👇
	for _, 字段 := range 元件.A字段组 {
		关联元件 := A取一对一或多的关联元件(字段)
		if 关联元件 == nil {
			continue
		}
		关联字段名 := 字段.A名称go
		子models := A取字段反射值(model, 关联字段名)
		for i := range 子models.Len() {
			子model指针 := A取子model指针(子models.Index(i))
			A增或改_单个_预处理_递归(tx, 子model指针, 关联元件, userID)
		}

		// 批量删除子级ids👇
		ids := A取字段值_数组(model, 关联字段名+"_拟删除子表ids")
		子model源 := 关联元件.Amodel
		if ids != nil {
			子表单项切片 := A成切片(子model源)
			// Unscoped 绕过软删除使用物理删除👇
			// tx = tx.Unscoped()
			err = tx.Delete(子表单项切片, "id in ?", ids).Error
			if err != nil {
				return err
			}
		}

		// switch 字段.A类型 {
		// case "关联字段":
		// 	关联属性 := A解对象(字段.A关联属性)
		// 	关联id := 关联属性["关联id"]
		// 	关联类型 := 关联属性["关联类型"]
		// 	if 关联类型 == A关联类型_属于 {
		// 		break
		// 	}
		// 	关联元件 := A元件集[关联id]
		// 	子model源 := 关联元件.Amodel
		// 	关联字段名 := 字段.A名称go
		// 	子models := A取字段反射值(model, 关联字段名)
		// 	// 外键字段名 := 字段.A外键字段名_go
		// 	// 遍历每个子model 增和改👇
		// 	for i := range 子models.Len() {
		// 		子model := A取反射el(子models.Index(i))
		// 		子model指针 := A取反射值指针(子model)
		// 		A增或改_单个_预处理_递归(tx, 子model指针, 关联元件, userID)
		// 	}

		// 	// 批量删除ids👇
		// 	ids := A取字段值_数组(model, 关联字段名+"_拟删除子表ids")
		// 	if ids != nil {
		// 		子表单项切片 := A成切片(子model源)
		// 		// Unscoped 绕过软删除使用物理删除👇
		// 		// tx = tx.Unscoped()
		// 		err = tx.Delete(子表单项切片, "id in ?", ids).Error
		// 		if err != nil {
		// 			return err
		// 		}
		// 	}
		// }
	}

	return nil
}

func A证流程权限(model any, 元件 *S元件) (err error) {
	状态 := A取状态(model)
	if 状态 != "" {
		流程设置 := 元件.A流程设置
		允许操作角色 := 流程设置.A允许操作角色
		if 允许操作角色 != nil {
			当前状态允许操作角色 := 允许操作角色[状态]
			当前角色 := Auser.Authority.AuthorityName
			if !slices.Contains(当前状态允许操作角色, 当前角色) {
				return fmt.Errorf(" 本状态👉 <b>%s</b> 下，该角色👉<b>%s</b> 没有操作权限！", 状态, 当前角色)
			}
		}

		if err = A证接管人(model, 元件); err != nil {
			return
		}
	}

	for _, 字段 := range 元件.A字段组 {
		关联元件 := A取一对一或多的关联元件(字段)
		if 关联元件 == nil {
			continue
		}
		关联字段名 := 字段.A名称go
		子models := A取字段反射值(model, 关联字段名)
		for i := range 子models.Len() {
			子model指针 := A取子model指针(子models.Index(i))
			if err = A证流程权限(子model指针, 关联元件); err != nil {
				return
			}
		}
	}
	return
}

func A证接管人(model any, 元件 *S元件) (err error) {
	流程动态, _ := A查单个_流程动态(model, 元件)
	if 流程动态.A操作人_M基础之用户modelID != Auser.ID {
		user := A取user(流程动态.A操作人_M基础之用户modelID)
		return fmt.Errorf(" 本状态👉 <b>%s</b> 由 <b>%s</b> 接管，您 没有操作权限！", 流程动态.A记录状态, user.UserName)
	}
	return
}

func A取子model指针(子model reflect.Value) (子model指针 any) {
	子model反射el := A取反射el(子model)
	子model指针 = A取反射值指针(子model反射el)
	return
}

func A增或改_单个_后处理_递归(model any, 元件 *S元件, userID uint, 简单点 bool) (err error) {
	改编号_有id后(model, "", 简单点)
	A予流程动态_接手(model, 元件, userID)
	for _, 字段 := range 元件.A字段组 {
		关联元件 := A取一对一或多的关联元件(字段)
		if 关联元件 == nil {
			continue
		}
		关联字段名 := 字段.A名称go
		子models := A取字段反射值(model, 关联字段名)
		for i := range 子models.Len() {
			子model指针 := A取子model指针(子models.Index(i))
			A增或改_单个_后处理_递归(子model指针, 关联元件, userID, true)
		}
		// switch 字段.A类型 {
		// case "关联字段":
		// 	关联属性 := A解对象(字段.A关联属性)
		// 	关联类型 := 关联属性["关联类型"]
		// 	if 关联类型 == A关联类型_属于 {
		// 		break
		// 	}
		// 	关联字段名 := 字段.A名称go
		// 	子models := A取字段反射值(model, 关联字段名)
		// 	// 外键字段名 := 字段.A外键字段名_go
		// 	// 遍历每个子model 增和改👇
		// 	for i := range 子models.Len() {
		// 		子model := A取反射el(子models.Index(i))
		// 		子model指针 := A取反射值指针(子model)
		// 		改编号_有id后(子model指针, "", true)
		// 	}
		// }
	}
	return nil
}

func A增或改_单个_可迭代_自行处理子表_废(tx *gorm.DB, model any, 元件 *S元件, userID uint) (err error) {
	if 元件.A自动挡hook.A增或改之前s7 != nil {
		if A反射调用(元件.A自动挡hook.A增或改之前s7, model) != nil {
			return err
		}
	}
	id := A取id(model)
	// 处理主表👇
	改编号_有id后(model, "", false)
	if id == 0 {
		// 新增
		if err = tx.Create(model).Error; err != nil {
			return err
		}
		记录创建用户(&userID, model)
	} else {
		if err = tx.Model(&model).Where("id =?", id).Updates(model).Error; err != nil {
			return err
		}
		记录更新用户(&userID, model)

	}

	// 处理关联字段
	for _, 字段 := range 元件.A字段组 {
		switch 字段.A类型 {
		case "关联字段":
			关联属性 := A解对象(字段.A关联属性)
			关联id := 关联属性["关联id"]
			关联类型 := 关联属性["关联类型"]
			关联元件 := A元件集[关联id]

			if 关联类型 == "一对多" {
				子model源 := 关联元件.Amodel
				关联字段名 := 字段.A名称go
				子models := A取字段反射值(model, 关联字段名)
				外键字段名 := 字段.A外键字段名_go
				// 遍历每个子model 增和改👇
				for i := 0; i < 子models.Len(); i++ {
					子model := A取反射el(子models.Index(i))
					子model指针 := A取反射值指针(子model)

					子表单项id := A取id(子model)
					改编号_有id后(子model指针, "", true)
					if 子表单项id == 0 {
						// 新增
						// 通过外键字段名用反射找到外键字段
						外键字段 := 子model.FieldByName(外键字段名)
						外键字段.SetUint(uint64(id))
						记录创建用户(&userID, 子model指针)
						if err = tx.Create(子model指针).Error; err != nil {
							return err
						}
					} else {
						// 更新
						记录更新用户(&userID, 子model指针)
						if err = tx.Model(子model源).Where("id =?", 子表单项id).Updates(子model指针).Error; err != nil {
							return err
						}
					}
				}

				// 批量删除ids👇
				ids := A取字段值_数组(model, 关联字段名+"_拟删除子表ids")
				if ids != nil {
					子表单项切片 := A成切片(子model源)
					// Unscoped 绕过软删除使用物理删除👇
					err = tx.Unscoped().Delete(子表单项切片, "id in ?", ids).Error
					if err != nil {
						return err
					}
				}

				// 什么情况下，才需要迭代？👇 遍历每个子model的时候执行吧？
				// if err2 := A增或改_单个_可迭代_自行处理子表_废(tx, &子model源, 关联元件, userID); err2 != nil {
				// 	return err2
				// }
			}
		}
	}
	return nil
}

func 改编号_有id后(model any, 前缀 string, 简单点 bool) {
	if !A有字段否(model, "A编号") {
		return
	}
	id := A取id(model)
	编号 := A取字符串字段值(model, "A编号")
	if 编号 == "" {
		if 简单点 {
			编号 = fmt.Sprintf("%d", id)
		} else {
			if 前缀 == "" {
				前缀 = "a"
				today := time.Now().Format("20060102")
				编号 = fmt.Sprintf("%s%s-%d", 前缀, today, id)
			}
		}
		A予字段值(model, "A编号", 编号)
	}
}

func 改编号_并提交(tx *gorm.DB, model any, 前缀 string, 简单点 bool) {
	if !A有字段否(model, "A编号") {
		return
	}
	id := A取id(model)
	编号 := A取字符串字段值(model, "A编号")
	if 编号 == "" {
		if 简单点 {
			编号 = fmt.Sprintf("%d", id)
		} else {
			if 前缀 == "" {
				前缀 = "a"
				today := time.Now().Format("20060102")
				编号 = fmt.Sprintf("%s%s-%d", 前缀, today, id)
			}
		}
		A予字段值(model, "A编号", 编号)
		tx.Model(&model).Where("id =?", id).Updates(model)
	}
}

func A成树组_非结构体版(单项组 []map[string]any, pid uint) []map[string]any {
	单层map := 成树单层map1(单项组)
	tree := 成树组_非结构体版_主体(pid, 单层map)
	return tree
}

func 成树组_非结构体版_主体(pid uint, 单层map map[uint][]map[string]any) (tree []map[string]any) {
	childrens := 单层map[pid]
	for _, 单项 := range childrens {
		id, _ := A转uint(单项["id"])
		// id, _ := A转uint(单项["value"])
		单项["children"] = 成树组_非结构体版_主体(id, 单层map)
		tree = append(tree, 单项)
	}
	return
}

func 成树单层map1(单项组 []map[string]any) (单层map map[uint][]map[string]any) {
	单层map = make(map[uint][]map[string]any)
	for _, 单项 := range 单项组 {
		父级id, _ := A转uint(单项["父级id"])
		单层map[父级id] = append(单层map[父级id], 单项)
	}
	return
}

func A废处理关联查询(db *gorm.DB, 元件 *S元件) {
	// 关联查询形如👇
	// if 元件.A名称 == "订单" {
	// 	db = db.Preload("A明细.A商品").Preload("A明细.Asku")
	// }

	// 处理关联字段
	for _, 字段 := range 元件.A字段组 {
		if 字段.A类型 == A字段类型_关联字段 {
			// 需要区分关联类型否？
			// 关联属性 := 字段.A关联属性
			// 关联类型 := 关联属性["关联类型"]
			// //形如👉 A商品  shangpin.S商品model  `json:"商品" gorm:"-"`
			// if 关联类型 == "一对一属于" {
			// 	// err = a0.A_DB.Preload("Good").Preload("SKU").Find(&list, "user_id = ?", userID).Error
			// 	db = db.Preload(字段.A名称go)
			// }

			关联字段名 := 字段.A名称go
			order := "ASC"
			db = db.Preload(关联字段名, func(subDB *gorm.DB) *gorm.DB {
				return subDB.Order("updated_at " + order)
			})
			关联元件 := 字段.A关联元件
			上层关联字段名 := 关联字段名
			// 暂时只处理 2 层
			if 关联元件 != nil {
				for _, 字段 := range 关联元件.A字段组 {
					if 字段.A类型 == A字段类型_关联字段 {
						关联字段名 := 字段.A名称go
						db = db.Preload(上层关联字段名 + "." + 关联字段名)
					}
				}
			}
		}
	}
}

// Preload需要在where之后，不然Preload会被清空👇
func 关联查询_可迭代(db *gorm.DB, 元件 *S元件, 迭代否 bool, 上层关联字段名 string) {
	// 关联查询形如👇
	// if 元件.A名称 == "订单" {
	// 	db = db.Preload("A明细.A商品").Preload("A明细.Asku")
	// }

	// 处理关联字段
	for _, 字段 := range 元件.A字段组 {
		if 字段.A类型 == A字段类型_关联字段 {
			// 需要区分关联类型否？
			// 关联属性 := 字段.A关联属性
			// 关联类型 := 关联属性["关联类型"]
			// //形如👉 A商品  shangpin.S商品model  `json:"商品" gorm:"-"`
			// if 关联类型 == "一对一属于" {
			// 	// err = a0.A_DB.Preload("Good").Preload("SKU").Find(&list, "user_id = ?", userID).Error
			// 	db = db.Preload(字段.A名称go)
			// }

			关联字段名 := 字段.A名称go
			关联字段全名 := 上层关联字段名 + 关联字段名
			// order := "ASC"
			order := "DESC"
			db = db.Preload(关联字段全名, func(subDB *gorm.DB) *gorm.DB {
				return subDB.Order("updated_at " + order)
			})
			关联元件 := 字段.A关联元件
			上层关联字段名 := 关联字段名 + "."

			if 迭代否 {
				关联查询_可迭代(db, 关联元件, 迭代否, 上层关联字段名)
			}

			// 暂时只处理 2 层
			// if 关联元件 != nil {
			// 	for _, 字段 := range 关联元件.A字段组 {
			// 		if 字段.A类型 == A字段类型_关联字段 {
			// 			关联字段名 := 字段.A名称go
			// 			db = db.Preload(上层关联字段名 + "." + 关联字段名)
			// 		}
			// 	}
			// }

		}
	}
}

func A成树组f(models any, pid uint) []any {
	// 获取 models 的反射值
	modelsValue := reflect.ValueOf(models)
	// 如果传入的是指针，获取指针指向的值
	if modelsValue.Kind() == reflect.Ptr {
		modelsValue = modelsValue.Elem()
	}
	var tree []any
	// 遍历切片中的每个元素
	for i := 0; i < modelsValue.Len(); i++ {
		// 获取当前元素
		model := modelsValue.Index(i)
		// 如果传入的是指针，获取指针指向的值
		if model.Kind() == reflect.Ptr {
			model = model.Elem()
		}
		// 获取 A父级id 字段的值
		parentIDField := model.FieldByName("A父级id")
		if !parentIDField.IsValid() || parentIDField.Kind() != reflect.Uint {
			continue
		}
		parentID := parentIDField.Uint()
		if parentID == uint64(pid) {
			idField := model.FieldByName("ID")
			if !idField.IsValid() || idField.Kind() != reflect.Uint {
				continue
			}
			id := idField.Uint()

			// 递归调用 A成树组 构建子树
			children := A成树组(models, uint(id))
			// 获取 Children 字段
			childrenField := model.FieldByName("Children")
			fmt.Printf("model.Kind() 👉 %+v\n", model.Kind())
			fmt.Printf("childrenField.Kind() 👉 %+v\n", childrenField.Kind())
			if childrenField.IsValid() && childrenField.Kind() == reflect.Slice {
				// 创建一个新的切片来存储子节点
				newChildren := reflect.MakeSlice(childrenField.Type(), len(children), len(children))
				for j, child := range children {
					newChildren.Index(j).Set(reflect.ValueOf(child))
				}
				// 设置 Children 字段的值
				childrenField.Set(newChildren)
			}

			// 将当前节点添加到树中
			tree = append(tree, model.Interface())
		}
	}
	return tree
}

func A取子级(models any, id uint) []any {
	modelMap := 成树单层map(models)
	return 取子级_主体(id, modelMap)
}

func 取子级_主体(id uint, modelMap map[uint][]any) []any {
	var 全部子级s []any
	子级s := modelMap[id]
	全部子级s = append(全部子级s, 子级s...)
	for _, child := range 子级s {
		childValue := A取反射el(child)
		子级id := A取id(childValue)
		取子级_主体(子级id, modelMap)
	}
	return 全部子级s
}

func A成树组(models any, pid uint) []any {
	modelMap := 成树单层map(models)
	tree := 成树组_主体(pid, modelMap)
	return tree
}

func 成树单层map(models any) map[uint][]any {
	modelsValue := A取反射el(models)
	modelMap := make(map[uint][]any)
	for i := 0; i < modelsValue.Len(); i++ {
		model := modelsValue.Index(i)
		model = A取反射el(model)
		// 获取 ParentID 字段的值
		parentIDField := model.FieldByName("A父级id")
		parentID := uint(parentIDField.Uint())
		// 将元素添加到对应的 ParentID 分组中
		// 下面必须使用指针，因为如果将值作为切片处理，它们将不可寻址 unaddressable
		// modelMap[parentID] = append(modelMap[parentID], model.Interface())
		modelMap[parentID] = append(modelMap[parentID], model.Addr().Interface())
	}
	return modelMap
}

func 成树组_主体(pid uint, modelMap map[uint][]any) (tree []any) {
	children := modelMap[pid]
	for _, child := range children {
		childValue := A取反射el(child)
		idField := childValue.FieldByName("ID")
		id := uint(idField.Uint())
		// 递归构建子树
		childrenTree := 成树组_主体(id, modelMap)
		// 获取 Children 字段
		childrenField := childValue.FieldByName("Children")
		if childrenField.IsValid() && childrenField.Kind() == reflect.Slice {
			newChildren := reflect.MakeSlice(childrenField.Type(), len(childrenTree), len(childrenTree))
			for j, subChild := range childrenTree {
				newChildren.Index(j).Set(reflect.ValueOf(subChild))
			}
			childrenField.Set(newChildren) // 现在可以设置
		}

		tree = append(tree, childValue.Interface()) // 使用 childValue.Interface() 获取完整的信息
	}
	return
}

func 记录更新用户多个(id *uint, models any) {
	models反射值 := A取反射el(models)
	for i := 0; i < models反射值.Len(); i++ {
		model := models反射值.Index(i).Interface()
		记录更新用户(id, model)
	}
}

func A予流程动态_接手(model any, 元件 *S元件, userID uint) {
	状态 := A取状态(model)
	if 状态 == "" {
		return
	}

	// id := A成id_从自己(元件)
	// 记录id := A取id(model)
	// 流程动态 := S流程动态model{
	// 	Aid: id,
	// 	A记录id: 记录id,
	// }
	// err := a0.A_DB.Where(&流程动态).First(&流程动态).Error
	流程动态, err := A查单个_流程动态(model, 元件)
	// 如果还没有对应接手人👇
	if err != nil {
		流程动态.A操作 = "接手"
		流程动态.A操作人_M基础之用户modelID = userID
		a0.A_DB.Save(&流程动态)
	}

	// 流程动态 := S流程动态model{}
	// 流程动态.Aid = A成id_从自己(元件)
	// 流程动态.A记录id = userID
	// 流程动态.A操作 = "接手"
	// 流程动态.A操作人_S用户modelID = userID
}

func A予状态_新增(model any, 元件 *S元件, userID uint) {
	if 元件.A状态候选值 == nil {
		return
	}
	状态候选值 := A解数组(元件.A状态候选值)
	if len(状态候选值) > 0 {
		状态 := 状态候选值[0]
		A予字段值(model, "A状态", 状态)
	}
}

func A予字段值_datatypes点json例子废(model any, 元件 *S元件, userID uint) {
	if 元件.A状态候选值 == nil {
		return
	}
	状态候选值 := A解数组(元件.A状态候选值)
	if len(状态候选值) > 0 {
		状态 := 状态候选值[0]
		A予字段值(model, "A状态", 状态)

		流程记录集 := make(map[string]*S流程记录)
		流程记录集[状态] = &S流程记录{
			A执行人: &userID,
		}
		A予字段值_datatypes点json(model, "A流程记录集", 流程记录集)
	}
}

func 记录删除用户(model any) {
	记录用户(&Auser.ID, model, "DeletedBy")
}

func 记录创建用户(id *uint, model any) {
	记录用户(id, model, "CreatedBy")
}

func 记录更新用户(id *uint, model any) {
	记录用户(id, model, "UpdatedBy")
}

func 记录用户(id *uint, model any, 字段名 string) {
	if !A有字段否(model, 字段名) {
		return
	}
	// userID := utils.GetUserID(c)
	A予字段值(model, 字段名, id)
}
